2. One-Parameter Exploration¶

We focus our attention on the vSRM configuration as it provides a practical solution to tuning the frequency response between observing runs. During one-parameter sweeps, all other parameters are held at their default values. Some cells may take a few minutes to execute. The parameters we investigate are:

  1. Common-mode tuning (move vSRM mirrors in the same direction) $\phi_\text{commm}$

  2. Differential-mode tuning (move vSRM mirrors in opposite directions) $\phi_\text{diff}$

  3. SRC length $L_\text{SRC}$

  4. ITM transmittivity $T_\text{ITM}$

All plots are made using plottly and are interactive! Have a play around to get some intuition about parameter space (as I did). Note that all the curves generated below do not include squeezing (simply add squeezing=True to any call to the function Finesse_sensitivity_into_Bilby to add squeezing).

In [6]:
import nemo_optimisation_modules as nom
import plotly.graph_objects as go
import plotly.io as pio
import numpy as np
pio.renderers.default='notebook'

default_phiComm = 0
default_phiDiff = 6.3565
default_srcL = 354
default_itmT = 0.01397

2.1 Example Sensitivity Curves¶

For each parameter the cells below will overlay five curves corresponding to different parameter values. The key observation here is that four-dimensional parameter space is very rich and there are many trade-offs e.g. higher sensitivity but lower bandwidth. It is not obvious a priori that extremising multiple parameters simultaneously will lead to an optimal design.

2.1.1 $\phi_\text{comm}$¶

In [3]:
vary_phiComm = [default_phiComm,1,3,6,10]

fig_qnoise = go.Figure()
fig_qnoise.update_xaxes(type="log")
fig_qnoise.update_yaxes(type="log")
fig_qnoise.update_layout(title="Common-Mode Tuning (phiComm) Example Curves",xaxis_title="Frequency [Hz]",yaxis_title="ASD (qnoised) [1/rt Hz]")

changed_itmT = True
store_prmT = 0
store_lasPow = 0
    
for phiComm in vary_phiComm:
    if changed_itmT:
        fsig, ASDarr, prmT, lasPow = nom.Finesse_sensitivity_into_Bilby(phiComm,default_phiDiff,default_srcL,default_itmT,prmT=0,lasPow=0,optimise_prmT=True,squeezing=False)
        print(f"CHECK phiComm: {phiComm}, Optimal prmT: {prmT}, Laser Power: {lasPow}")
        fig_qnoise.add_trace(go.Scatter(x=fsig, y=ASDarr,mode='lines+markers',name=f"phiComm={phiComm}"))
        store_prmT = prmT
        store_lasPow = lasPow
        changed_itmT = False
    else: 
        fsig, ASDarr, prmT, lasPow = nom.Finesse_sensitivity_into_Bilby(phiComm,default_phiDiff,default_srcL,default_itmT,prmT=store_prmT,lasPow=store_lasPow,optimise_prmT=False,squeezing=False)
        print(f"CHECK phiComm: {phiComm}, Optimal prmT: {prmT}, Laser Power: {lasPow}")
        fig_qnoise.add_trace(go.Scatter(x=fsig, y=ASDarr,mode='lines+markers',name=f"phiComm={phiComm}"))
        
fig_qnoise.show()

CHECK phiComm: 0, Optimal prmT: 0.013186489467542296, Laser Power: 428
CHECK phiComm: 1, Optimal prmT: 0.013186489467542296, Laser Power: 428.0
CHECK phiComm: 3, Optimal prmT: 0.013186489467542296, Laser Power: 428.0
CHECK phiComm: 6, Optimal prmT: 0.013186489467542296, Laser Power: 428.0
CHECK phiComm: 10, Optimal prmT: 0.013186489467542296, Laser Power: 428.0

2.1.2 $\phi_\text{diff}$¶

In [4]:
vary_phiDiff = [1,2,4,default_phiDiff,10]

fig_qnoise = go.Figure()
fig_qnoise.update_xaxes(type="log")
fig_qnoise.update_yaxes(type="log")
fig_qnoise.update_layout(title="Differential-Mode Tuning (phiDiff) Example Curves",xaxis_title="Frequency [Hz]",yaxis_title="ASD (qnoised) [1/rt Hz]")
    
changed_itmT = True
store_prmT = 0
store_lasPow = 0
    
for phiDiff in vary_phiDiff:
    if changed_itmT:
        fsig, ASDarr, prmT, lasPow = nom.Finesse_sensitivity_into_Bilby(default_phiComm,phiDiff,default_srcL,default_itmT,prmT=0,lasPow=0,optimise_prmT=True,squeezing=False)
        print(f"CHECK phiDiff: {phiDiff}, Optimal prmT: {prmT}, Laser Power: {lasPow}")
        fig_qnoise.add_trace(go.Scatter(x=fsig, y=ASDarr,mode='lines+markers',name=f"phiDiff={phiDiff}"))
        store_prmT = prmT
        store_lasPow = lasPow
        changed_itmT = False
    else: 
        fsig, ASDarr, prmT, lasPow = nom.Finesse_sensitivity_into_Bilby(default_phiComm,phiDiff,default_srcL,default_itmT,prmT=store_prmT,lasPow=store_lasPow,optimise_prmT=False,squeezing=False)
        print(f"CHECK phiDiff: {phiDiff}, Optimal prmT: {prmT}, Laser Power: {lasPow}")
        fig_qnoise.add_trace(go.Scatter(x=fsig, y=ASDarr,mode='lines+markers',name=f"phiDiff={phiDiff}"))
        
fig_qnoise.show()

CHECK phiDiff: 1, Optimal prmT: 0.013186489467542296, Laser Power: 428
CHECK phiDiff: 2, Optimal prmT: 0.013186489467542296, Laser Power: 428.0
CHECK phiDiff: 4, Optimal prmT: 0.013186489467542296, Laser Power: 428.0
CHECK phiDiff: 6.3565, Optimal prmT: 0.013186489467542296, Laser Power: 428.0
CHECK phiDiff: 10, Optimal prmT: 0.013186489467542296, Laser Power: 428.0

2.1.3 $L_\text{SRC}$¶

In [7]:
vary_srcL = [50,150,default_srcL,600,1000]

fig_qnoise = go.Figure()
fig_qnoise.update_xaxes(type="log")
fig_qnoise.update_yaxes(type="log")
fig_qnoise.update_layout(title="SRC Length (srcL) Example Curves",xaxis_title="Frequency [Hz]",yaxis_title="ASD (qnoised) [1/rt Hz]")

changed_itmT = True
store_prmT = 0
store_lasPow = 0

for srcL in vary_srcL:
    if changed_itmT:
        fsig, ASDarr, prmT, lasPow = nom.Finesse_sensitivity_into_Bilby(default_phiComm,default_phiDiff,srcL,default_itmT,prmT=0,lasPow=0,optimise_prmT=True,squeezing=False)
        print(f"CHECK srcL: {srcL}, Optimal prmT: {prmT}, Laser Power: {lasPow}")
        fig_qnoise.add_trace(go.Scatter(x=fsig, y=ASDarr,mode='lines+markers',name=f"srcL={srcL}"))
        store_prmT = prmT
        store_lasPow = lasPow
        changed_itmT = False
    else:
        fsig, ASDarr, prmT, lasPow = nom.Finesse_sensitivity_into_Bilby(default_phiComm,default_phiDiff,srcL,default_itmT,prmT=store_prmT,lasPow=store_lasPow,optimise_prmT=False,squeezing=False)
        print(f"CHECK srcL: {srcL}, Optimal prmT: {prmT}, Laser Power: {lasPow}")
        fig_qnoise.add_trace(go.Scatter(x=fsig, y=ASDarr,mode='lines+markers',name=f"srcL={srcL}"))
fig_qnoise.show()

CHECK srcL: 50, Optimal prmT: 0.013186489467542296, Laser Power: 428
CHECK srcL: 150, Optimal prmT: 0.013186489467542296, Laser Power: 428.0
CHECK srcL: 354, Optimal prmT: 0.013186489467542296, Laser Power: 428.0
CHECK srcL: 600, Optimal prmT: 0.013186489467542296, Laser Power: 428.0
CHECK srcL: 1000, Optimal prmT: 0.013186489467542296, Laser Power: 428.0

2.1.4 $T_\text{ITM}$¶

In [9]:
vary_itmT = [0.005,0.01,default_itmT,0.02,0.05]

fig_qnoise = go.Figure()
fig_qnoise.update_xaxes(type="log")
fig_qnoise.update_yaxes(type="log")
fig_qnoise.update_layout(title="ITM Transmission (itmT) Example Curves",xaxis_title="Frequency [Hz]",yaxis_title="ASD (qnoised) [1/rt Hz]")

for itmT in vary_itmT:
    fsig, ASDarr, prmT, lasPow = nom.Finesse_sensitivity_into_Bilby(default_phiComm,default_phiDiff,default_srcL,itmT,prmT=0,lasPow=0,optimise_prmT=True,squeezing=False)
    print(f"CHECK itmT: {itmT}, Optimal prmT: {prmT}, Laser Power: {lasPow}")
    fig_qnoise.add_trace(go.Scatter(x=fsig, y=ASDarr,mode='lines+markers',name=f"itmT={itmT}"))
    
fig_qnoise.show()

CHECK itmT: 0.005, Optimal prmT: 0.03541294309885406, Laser Power: 414
CHECK itmT: 0.01, Optimal prmT: 0.018818326997598396, Laser Power: 422
CHECK itmT: 0.01397, Optimal prmT: 0.013186489467542296, Laser Power: 428
CHECK itmT: 0.02, Optimal prmT: 0.01, Laser Power: 438
CHECK itmT: 0.05, Optimal prmT: 0.01, Laser Power: 550

2.2 Sensitivity Curve vs. Parameter Surface (3D)¶

For each parameter we can visualise how the sensitivity curve changes by plotting parameter vs. frequency vs. sensitivity.

2.2.1 $\phi_\text{comm}$¶

In [10]:
vary_phiComm = np.geomspace(1e-1,180,101)
fsig = np.geomspace(100,10e3,201)
sens = np.zeros((101,201))
peak_sens_phiComm = np.zeros(101)
peak_f_phiComm = np.zeros(101)
peak_bw_phiComm = np.zeros(101)

changed_itmT = True
store_prmT = 0
store_lasPow = 0

for i, phiComm in enumerate(vary_phiComm):
    if changed_itmT:
        fsig, ASDarr, prmT, lasPow, peak_dict = nom.Finesse_sensitivity_into_Bilby(phiComm,default_phiDiff,default_srcL,default_itmT,prmT=0,lasPow=0,optimise_prmT=True,export_peaks=True)
        sens[i,:] = ASDarr
        store_prmT = prmT
        store_lasPow = lasPow
        changed_itmT = False
        peak_sens_phiComm[i] = peak_dict['peak_sens']
        peak_f_phiComm[i] = peak_dict['peak_f']
        peak_bw_phiComm[i] = peak_dict['peak_bw']
    else: 
        fsig, ASDarr, prmT, lasPow, peak_dict = nom.Finesse_sensitivity_into_Bilby(phiComm,default_phiDiff,default_srcL,default_itmT,store_prmT,store_lasPow,optimise_prmT=False,export_peaks=True)
        sens[i,:] = ASDarr
        peak_sens_phiComm[i] = peak_dict['peak_sens']
        peak_f_phiComm[i] = peak_dict['peak_f']
        peak_bw_phiComm[i] = peak_dict['peak_bw']

fig_surf = go.Figure(data=[go.Surface(x=fsig,y=vary_phiComm,z=np.log10(sens),opacity=0.5)])
fig_surf.update_layout(scene=dict(xaxis=dict(type='log',title="Frequency [Hz]"),
                             yaxis=dict(title="phiComm [deg]"),
                            zaxis=dict(title="log ASD (qnoised) [1/rt Hz]")))
fig_surf.update_layout(title='Sensitivity vs. phiComm')
fig_surf.show()

2.2.2 $\phi_\text{diff}$¶

In [11]:
vary_phiDiff = np.geomspace(1e-1,180-1e-1,101)  # At 180deg 
fsig = np.geomspace(100,10e3,201)
sens = np.zeros((101,201))
peak_sens_phiDiff = np.zeros(101)
peak_f_phiDiff = np.zeros(101)
peak_bw_phiDiff = np.zeros(101)

changed_itmT = True
store_prmT = 0
store_lasPow = 0

for i, phiDiff in enumerate(vary_phiDiff):
    if changed_itmT:
        fsig, ASDarr, prmT, lasPow, peak_dict = nom.Finesse_sensitivity_into_Bilby(default_phiComm,phiDiff,default_srcL,default_itmT,prmT=0,lasPow=0,optimise_prmT=True,export_peaks=True)
        sens[i,:] = ASDarr
        store_prmT = prmT
        store_lasPow = lasPow
        changed_itmT = False
        peak_sens_phiDiff[i] = peak_dict['peak_sens']
        peak_f_phiDiff[i] = peak_dict['peak_f']
        peak_bw_phiDiff[i] = peak_dict['peak_bw']
    else: 
        fsig, ASDarr, prmT, lasPow, peak_dict = nom.Finesse_sensitivity_into_Bilby(default_phiComm,phiDiff,default_srcL,default_itmT,store_prmT,store_lasPow,optimise_prmT=False,export_peaks=True)
        sens[i,:] = ASDarr
        peak_sens_phiDiff[i] = peak_dict['peak_sens']
        peak_f_phiDiff[i] = peak_dict['peak_f']
        peak_bw_phiDiff[i] = peak_dict['peak_bw']

fig_surf = go.Figure(data=[go.Surface(x=fsig,y=vary_phiDiff,z=np.log10(sens),opacity=0.5)])
fig_surf.update_layout(scene=dict(xaxis=dict(type='log',title="Frequency [Hz]"),
                             yaxis=dict(title="phiDiff [deg]"),
                            zaxis=dict(title="log ASD (qnoised) [1/rt Hz]")))
fig_surf.update_layout(title='Sensitivity vs. phiDiff')
fig_surf.show()

2.2.3 $L_\text{SRC}$¶

In [12]:
vary_srcL = np.geomspace(10,1e3,101)
fsig = np.geomspace(100,10e3,201)
sens = np.zeros((101,201))
peak_sens_srcL = np.zeros(101)
peak_f_srcL = np.zeros(101)
peak_bw_srcL = np.zeros(101)

changed_itmT = True
store_prmT = 0
store_lasPow = 0

for i, srcL in enumerate(vary_srcL):
    if changed_itmT:
        fsig, ASDarr, prmT, lasPow, peak_dict = nom.Finesse_sensitivity_into_Bilby(default_phiComm,default_phiDiff,srcL,default_itmT,prmT=0,lasPow=0,optimise_prmT=True,export_peaks=True)
        sens[i,:] = ASDarr
        store_prmT = prmT
        store_lasPow = lasPow
        changed_itmT = False
        peak_sens_srcL[i] = peak_dict['peak_sens']
        peak_f_srcL[i] = peak_dict['peak_f']
        peak_bw_srcL[i] = peak_dict['peak_bw']
    else: 
        fsig, ASDarr, prmT, lasPow, peak_dict = nom.Finesse_sensitivity_into_Bilby(default_phiComm,default_phiDiff,srcL,default_itmT,store_prmT,store_lasPow,optimise_prmT=False,export_peaks=True)
        sens[i,:] = ASDarr
        peak_sens_srcL[i] = peak_dict['peak_sens']
        peak_f_srcL[i] = peak_dict['peak_f']
        peak_bw_srcL[i] = peak_dict['peak_bw']

fig_surf = go.Figure(data=[go.Surface(x=fsig,y=vary_srcL,z=np.log10(sens),opacity=0.5)])
fig_surf.update_layout(scene=dict(xaxis=dict(type='log',title="Frequency [Hz]"),
                             yaxis=dict(title="srcL [m]"),
                            zaxis=dict(title="log ASD (qnoised) [1/rt Hz]")))
fig_surf.update_layout(title='Sensitivity vs. srcL')
fig_surf.show()

2.2.4 $T_\text{ITM}$¶

When $T_\text{ITM}$ is changed, $T_\text{PRM}$ is re-calculated to meet the impedance-matching condition i.e. the arm circulating power is maximised. Afterwards, the input laser power is increased from 500W (up to 550W at most) or decreased until the nominal value for arm circulating power (4.5MW) is reached. The colour on the first surface plot is $T_\text{PRM}$, the second is the laser power. This process takes a long time so the generating code is commented out (use load and find the associated numpy array in ./SaveArrays/).
Observations: See SaveArrays/SaveArrays/Sec2.2.4_store_prmT.npy that for many $T_\text{ITM}>0.01$, the impedance-matched $T_\text{PRM}$ saturates at 0.01 (and is the case for the preliminary optimal detector design in Section 4). We subsequently decrease the lower limit from 1e-2 to 1e-3.

In [18]:
vary_itmT = np.geomspace(1e-3,0.5,101)
fsig = np.geomspace(100,10e3,201)
# sens = np.zeros((101,201))
# store_prmT = np.zeros((101,201))
# store_lasPow = np.zeros((101,201))
# peak_sens_itmT = np.zeros(101)
# peak_f_itmT = np.zeros(101)
# peak_bw_itmT = np.zeros(101)

# for i, itmT in enumerate(vary_itmT):
#         fsig, ASDarr, prmT, lasPow, peak_dict = nom.Finesse_sensitivity_into_Bilby(default_phiDiff,default_phiComm,default_srcL,itmT,prmT=0,lasPow=0,optimise_prmT=True,export_peaks=True)
#         sens[i,:] = ASDarr
#         store_prmT[i,:] = np.repeat(prmT, 201)
#         store_lasPow[i,:] = np.repeat(lasPow, 201)
#         peak_sens_itmT[i] = peak_dict['peak_sens']
#         peak_f_itmT[i] = peak_dict['peak_f']
#         peak_bw_itmT[i] = peak_dict['peak_bw']

# np.save("SaveArrays/Sec2.2.4_store_prmT_lowerLim.npy",store_prmT)
# np.save("SaveArrays/Sec2.2.4_store_sens_lowerLim.npy",sens)
# np.save("SaveArrays/Sec2.2.4_store_peak_sens_itmT_lowerLim.npy",peak_sens_itmT)
# np.save("SaveArrays/Sec2.2.4_store_peak_f_itmT_lowerLim.npy",peak_f_itmT)
# np.save("SaveArrays/Sec2.2.4_store_peak_bw_itmT_lowerLim.npy",peak_bw_itmT)
# np.save("SaveArrays/Sec2.2.4_store_lasPow_lowerLim.npy",store_lasPow)

sens = np.load("SaveArrays/Sec2.2.4_store_sens_lowerLim.npy")
store_prmT = np.load("SaveArrays/Sec2.2.4_store_prmT_lowerLim.npy")
store_lasPow = np.load("SaveArrays/Sec2.2.4_store_lasPow_lowerLim.npy")
peak_sens_itmT = np.load("SaveArrays/Sec2.2.4_store_peak_sens_itmT_lowerLim.npy")
peak_f_itmT = np.load("SaveArrays/Sec2.2.4_store_peak_f_itmT_lowerLim.npy")
peak_bw_itmT = np.load("SaveArrays/Sec2.2.4_store_peak_bw_itmT_lowerLim.npy")

fig_sens = go.Figure(data=[go.Surface(x=fsig,y=vary_itmT,z=np.log10(sens),opacity=0.5)])
fig_sens.update_layout(scene=dict(xaxis=dict(type='log',title="Frequency [Hz]"),yaxis=dict(title="itmT"),zaxis=dict(title="log ASD (qnoised) [1/rt Hz]")))
fig_sens.update_layout(title='Sensitivity vs. itmT')
fig_sens.show()

fig_prmT = go.Figure(data=[go.Surface(x=fsig,y=vary_itmT,z=store_prmT,opacity=0.5)])
fig_prmT.update_layout(scene=dict(xaxis=dict(type='log',title="Frequency [Hz]"),yaxis=dict(title="itmT"),zaxis=dict(title="prmT")))
fig_prmT.update_layout(title='prmT vs. itmT')
fig_prmT.show()

fig_lasPow = go.Figure(data=[go.Surface(x=fsig,y=vary_itmT,z=store_lasPow,opacity=0.5)])
fig_lasPow.update_layout(scene=dict(xaxis=dict(type='log',title="Frequency [Hz]"),yaxis=dict(title="itmT"),zaxis=dict(title="lasPow [W]")))
fig_lasPow.update_layout(title='lasPow vs. itmT')
fig_lasPow.show()

2.3 Peak Properties vs. Parameter¶

Using the negative ASD curve, scipy's standard findpeaks function is used to find the first peak (if it exists). The bandwidth is calculated as the full width at half maximum using scipy's peak_widths function. If no peak is found, no data is plotted (hence, the gaps in some plots). The half maximum frequencies are interpolated on the log frequency scale using scipy's interp1d function. Each of these peak properties is plotted against the parameter. The ideal peak has a peak frequency in the band 2-4kHz (containing the most import post-merger spectral information), high peak sensitivity (small ASD), and high bandwidth. Note that the parameters are log-spaced (favouring higher resolution near small values near the default NEMO parameters).

Note: Run Section 2.2.X to get peak data for 2.3.X first! (the below cells are purely plotting functions.)

2.3.1 $\phi_\text{comm}$¶

In [19]:
fig_peak_sens = go.Figure()
fig_peak_sens.add_trace(go.Scatter(x=vary_phiComm, y=peak_sens_phiComm,mode='lines+markers',name='Peak Frequency'))
fig_peak_sens.update_layout(title="Peak Sensitivity vs. phiComm",xaxis_title="phiComm [deg]",yaxis_title="Peak Sensitivity [1/rt Hz]")
fig_peak_sens.show()

fig_peak_f = go.Figure()
fig_peak_f.add_trace(go.Scatter(x=vary_phiComm, y=peak_f_phiComm,mode='lines+markers',name='Peak'))
fig_peak_f.update_layout(title="Peak Frequency vs. phiComm",xaxis_title="phiComm [deg]",yaxis_title="Peak Frequency [Hz]")
fig_peak_f.show()

fig_peak_bw = go.Figure()
fig_peak_bw.add_trace(go.Scatter(x=vary_phiComm, y=peak_bw_phiComm,mode='lines+markers',name='Peak'))
fig_peak_bw.update_layout(title="Peak Bandwidth vs. phiComm",xaxis_title="phiComm [deg]",yaxis_title="Peak Bandwidth [Hz]")
fig_peak_bw.show()

2.3.2 $\phi_\text{diff}$¶

In [20]:
fig_peak_sens = go.Figure()
fig_peak_sens.add_trace(go.Scatter(x=vary_phiDiff, y=peak_sens_phiDiff,mode='lines+markers',name='Peak Frequency'))
fig_peak_sens.update_layout(title="Peak Sensitivity vs. phiDiff",xaxis_title="phiDiff [deg]",yaxis_title="Peak Sensitivity [1/rt Hz]")
fig_peak_sens.show()

fig_peak_f = go.Figure()
fig_peak_f.add_trace(go.Scatter(x=vary_phiDiff, y=peak_f_phiDiff,mode='lines+markers',name='Peak'))
fig_peak_f.update_layout(title="Peak Frequency vs. phiDiff",xaxis_title="phiDiff [deg]",yaxis_title="Peak Frequency [Hz]")
fig_peak_f.show()

fig_peak_bw = go.Figure()
fig_peak_bw.add_trace(go.Scatter(x=vary_phiDiff, y=peak_bw_phiDiff,mode='lines+markers',name='Peak'))
fig_peak_bw.update_layout(title="Peak Bandwidth vs. phiDiff",xaxis_title="phiDiff [deg]",yaxis_title="Peak Bandwidth [Hz]")
fig_peak_bw.show()

2.3.3 $L_\text{SRC}$¶

In [21]:
fig_peak_sens = go.Figure()
fig_peak_sens.add_trace(go.Scatter(x=vary_srcL, y=peak_sens_srcL,mode='lines+markers',name='Peak Frequency'))
fig_peak_sens.update_layout(title="Peak Sensitivity vs. srcL",xaxis_title="srcL [deg]",yaxis_title="Peak Sensitivity [1/rt Hz]")
fig_peak_sens.show()

fig_peak_f = go.Figure()
fig_peak_f.add_trace(go.Scatter(x=vary_srcL, y=peak_f_srcL,mode='lines+markers',name='Peak'))
fig_peak_f.update_layout(title="Peak Frequency vs. srcL",xaxis_title="srcL [deg]",yaxis_title="Peak Frequency [Hz]")
fig_peak_f.show()

fig_peak_bw = go.Figure()
fig_peak_bw.add_trace(go.Scatter(x=vary_srcL, y=peak_bw_srcL,mode='lines+markers',name='Peak'))
fig_peak_bw.update_layout(title="Peak Bandwidth vs. srcL",xaxis_title="srcL [deg]",yaxis_title="Peak Bandwidth [Hz]")
fig_peak_bw.show()

2.3.4 $T_\text{ITM}$¶

TODO: Determine why the curves are significantly not as smooth as for the other parameters (including at high resolution).

In [24]:
fig_peak_sens = go.Figure()
fig_peak_sens.add_trace(go.Scatter(x=vary_itmT, y=peak_sens_itmT,mode='lines+markers',name='Peak Frequency'))
fig_peak_sens.update_layout(title="Peak Sensitivity vs. itmT",xaxis_title="itmT",yaxis_title="Peak Sensitivity [1/rt Hz]")
fig_peak_sens.show()

fig_peak_f = go.Figure()
fig_peak_f.add_trace(go.Scatter(x=vary_itmT, y=peak_f_itmT,mode='lines+markers',name='Peak'))
fig_peak_f.update_layout(title="Peak Frequency vs. itmT",xaxis_title="itmT",yaxis_title="Peak Frequency [Hz]")
fig_peak_f.show()

fig_peak_bw = go.Figure()
fig_peak_bw.add_trace(go.Scatter(x=vary_itmT, y=peak_bw_itmT,mode='lines+markers',name='Peak'))
fig_peak_bw.update_layout(title="Peak Bandwidth vs. itmT",xaxis_title="itmT",yaxis_title="Peak Bandwidth [Hz]")
fig_peak_bw.show()
In [ ]: